package com.hins.sparseArray;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Objects;

/**
 * 稀疏数组sparseArray,当数组中含有多个相同的元素，可以压缩数据
 * 1）第一行 几行几列 几个不同有效数据（row col val)
 * 2）其余行记录其在原始二维数组的位置
 *
 * 二维数组转为稀疏数组
 * 1）遍历 原始二维数组 得到有效数据个数sum
 * 2）根据sum创建 稀疏数组sparseArr int[sum+1][3]
 * 3）将二维数组的有效数据存入到稀疏数组中
 * 稀疏数组转原始二维数组
 * 1）先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
 * 2）读取稀疏数组后几行的数据，并赋值给原始二维数组。
 *
 */
public class SparseArray {
    public static void main(String[] args) {
        int[][] arr1 = new int[11][11];
        arr1[1][2] = 1;
        arr1[2][3] = 2;
        arr1[5][3] = 2;
        System.out.println("原始的二维数组：");
        for (int[] row : arr1) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        // 遍历二维数组，得到非0数据的个数
        int sum = 0;
        for (int[] row : arr1) {
            for (int data : row) {
                if (data != 0) {
                    sum++;
                }
            }
        }

        //创建对应的稀疏数组
        int[][] sparseArr = new int[sum + 1][3];
        //给稀疏数组赋值
        sparseArr[0][0] = arr1.length;
        sparseArr[0][1] = arr1[0].length;
        sparseArr[0][2] = sum;

        //遍历二维数组，将非零数据存入稀疏数组
        int count = 0;
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                if (arr1[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arr1[i][j];
                }
            }
        }

        // 输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int[] row : sparseArr) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        // 将稀疏数组保存到磁盘中
        save(sparseArr,"map.data");

        // 读出
        String[] ss = Objects.requireNonNull(readOut("map.data")).trim().split(",");
        int[][] sparseA = new int[ss.length/3][3];

        int j = 0;
        for (int i = 0; i < ss.length - 2; i += 3){
            sparseA[j][0] = Integer.parseInt(ss[i]);
            sparseA[j][1] = Integer.parseInt(ss[i+1]);
            sparseA[j][2] = Integer.parseInt(ss[i+2]);
            j++;
        }

        System.out.println();
        System.out.println("从磁盘中得到的稀疏数组为：");
        for (int[] row : sparseA){
            for (int data : row){
                System.out.print(data+"\t");
            }
            System.out.println();
        }

        //將稀疏数组转化为 原始二维数组
        System.out.println();
        System.out.println("恢复后的二维数组为：");
        int[][] arr2 = new int[sparseA[0][0]][sparseA[0][1]];
        for (int i = 1; i < sparseA.length; i++) {
            arr2[sparseA[i][0]][sparseA[i][1]] = sparseA[i][2];
        }

        for (int[] row:arr2){
            for(int data:row){
                System.out.print(data+"\t");
            }
            System.out.println();
        }

    }

    /**
     * 存入磁盘
     */
    public static void save(int[][] arr,String fileUrl){
        String str="";
        for (int[] row : arr) {
            for (int data : row) {
                str=str+","+data;
            }
        }
        try {
            FileWriter fw=new FileWriter(fileUrl);
            fw.write(str);
            fw.flush();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 从磁盘中读取
     */
    public static String readOut(String fileUrl){
        String s = "";
        try {
            FileReader fr = new FileReader(fileUrl);
            int len=0;
            char[] c = new char[10];
            while ((len=fr.read(c))!=-1) {
                s += new String(c,0,len);
            }
            s = s.substring(1);
            fr.close();
            return s;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}
